home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 24 / AACD 24.iso / AACD / Sound / LAME / WarpOS / src / mpglib / layer3.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-06-12  |  46.7 KB  |  1,796 lines
  1. /* 
  2.  * Mpeg Layer-3 audio decoder 
  3.  * --------------------------
  4.  * copyright (c) 1995,1996,1997 by Michael Hipp.
  5.  * All rights reserved. See also 'README'
  6.  */ 
  7.  
  8. /* $Id: layer3.c,v 1.43 2001/06/04 10:01:35 afaber Exp $ */
  9.  
  10. #ifdef HAVE_CONFIG_H
  11. # include <config.h>
  12. #endif
  13.  
  14. #include <stdlib.h>
  15. #include "common.h"
  16. #include "huffman.h"
  17. #include "lame-analysis.h"
  18. #include "decode_i386.h"
  19.  
  20. #ifdef WITH_DMALLOC
  21. #include <dmalloc.h>
  22. #endif
  23.  
  24. #define MPEG1
  25.  
  26.  
  27. static real ispow[8207];
  28. static real aa_ca[8],aa_cs[8];
  29. static real COS1[12][6];
  30. static real win[4][36];
  31. static real win1[4][36];
  32. static real gainpow2[256+118+4];
  33. static real COS9[9];
  34. static real COS6_1,COS6_2;
  35. static real tfcos36[9];
  36. static real tfcos12[3];
  37.  
  38. struct bandInfoStruct {
  39.   short longIdx[23];
  40.   short longDiff[22];
  41.   short shortIdx[14];
  42.   short shortDiff[13];
  43. };
  44.  
  45. int longLimit[9][23];
  46. int shortLimit[9][14];
  47.  
  48. const struct bandInfoStruct bandInfo[9] = { 
  49.  
  50. /* MPEG 1.0 */
  51.  { {0,4,8,12,16,20,24,30,36,44,52,62,74, 90,110,134,162,196,238,288,342,418,576},
  52.    {4,4,4,4,4,4,6,6,8, 8,10,12,16,20,24,28,34,42,50,54, 76,158},
  53.    {0,4*3,8*3,12*3,16*3,22*3,30*3,40*3,52*3,66*3, 84*3,106*3,136*3,192*3},
  54.    {4,4,4,4,6,8,10,12,14,18,22,30,56} } ,
  55.  
  56.  { {0,4,8,12,16,20,24,30,36,42,50,60,72, 88,106,128,156,190,230,276,330,384,576},
  57.    {4,4,4,4,4,4,6,6,6, 8,10,12,16,18,22,28,34,40,46,54, 54,192},
  58.    {0,4*3,8*3,12*3,16*3,22*3,28*3,38*3,50*3,64*3, 80*3,100*3,126*3,192*3},
  59.    {4,4,4,4,6,6,10,12,14,16,20,26,66} } ,
  60.  
  61.  { {0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576} ,
  62.    {4,4,4,4,4,4,6,6,8,10,12,16,20,24,30,38,46,56,68,84,102, 26} ,
  63.    {0,4*3,8*3,12*3,16*3,22*3,30*3,42*3,58*3,78*3,104*3,138*3,180*3,192*3} ,
  64.    {4,4,4,4,6,8,12,16,20,26,34,42,12} }  ,
  65.  
  66. /* MPEG 2.0 */
  67.  { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
  68.    {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 } ,
  69.    {0,4*3,8*3,12*3,18*3,24*3,32*3,42*3,56*3,74*3,100*3,132*3,174*3,192*3} ,
  70.    {4,4,4,6,6,8,10,14,18,26,32,42,18 } } ,
  71.                                              /* docs: 332. mpg123: 330 */
  72.  { {0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,332,394,464,540,576},
  73.    {6,6,6,6,6,6,8,10,12,14,16,18,22,26,32,38,46,54,62,70,76,36 } ,
  74.    {0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,136*3,180*3,192*3} ,
  75.    {4,4,4,6,8,10,12,14,18,24,32,44,12 } } ,
  76.  
  77.  { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
  78.    {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 },
  79.    {0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,134*3,174*3,192*3},
  80.    {4,4,4,6,8,10,12,14,18,24,30,40,18 } } ,
  81. /* MPEG 2.5 */
  82.  { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} ,
  83.    {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54},
  84.    {0,12,24,36,54,78,108,144,186,240,312,402,522,576},
  85.    {4,4,4,6,8,10,12,14,18,24,30,40,18} },
  86.  { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} ,
  87.    {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54},
  88.    {0,12,24,36,54,78,108,144,186,240,312,402,522,576},
  89.    {4,4,4,6,8,10,12,14,18,24,30,40,18} },
  90.  { {0,12,24,36,48,60,72,88,108,132,160,192,232,280,336,400,476,566,568,570,572,574,576},
  91.    {12,12,12,12,12,12,16,20,24,28,32,40,48,56,64,76,90,2,2,2,2,2},
  92.    {0, 24, 48, 72,108,156,216,288,372,480,486,492,498,576},
  93.    {8,8,8,12,16,20,24,28,36,2,2,2,26} } ,
  94. };
  95.  
  96. static int mapbuf0[9][152];
  97. static int mapbuf1[9][156];
  98. static int mapbuf2[9][44];
  99. static int *map[9][3];
  100. static int *mapend[9][3];
  101.  
  102. static unsigned int n_slen2[512]; /* MPEG 2.0 slen for 'normal' mode */
  103. static unsigned int i_slen2[256]; /* MPEG 2.0 slen for intensity stereo */
  104.  
  105. static real tan1_1[16],tan2_1[16],tan1_2[16],tan2_2[16];
  106. static real pow1_1[2][16],pow2_1[2][16],pow1_2[2][16],pow2_2[2][16];
  107.  
  108. static unsigned int get1bit(void)
  109. {
  110.   unsigned char rval;
  111.   rval = *wordpointer << bitindex;
  112.  
  113.   bitindex++;
  114.   wordpointer += (bitindex>>3);
  115.   bitindex &= 7;
  116.  
  117.   return rval>>7;
  118. }
  119.  
  120.  
  121.  
  122.  
  123. /* 
  124.  * init tables for layer-3 
  125.  */
  126. void init_layer3(int down_sample_sblimit)
  127. {
  128.   int i,j,k;
  129.  
  130.   for(i=-256;i<118+4;i++)
  131.     gainpow2[i+256] = pow((double)2.0,-0.25 * (double) (i+210) );
  132.  
  133.   for(i=0;i<8207;i++)
  134.     ispow[i] = pow((double)i,(double)4.0/3.0);
  135.  
  136.   for (i=0;i<8;i++)
  137.   {
  138.     static double Ci[8]={-0.6,-0.535,-0.33,-0.185,-0.095,-0.041,-0.0142,-0.0037};
  139.     double sq=sqrt(1.0+Ci[i]*Ci[i]);
  140.     aa_cs[i] = 1.0/sq;
  141.     aa_ca[i] = Ci[i]/sq;
  142.   }
  143.  
  144.   for(i=0;i<18;i++)
  145.   {
  146.     win[0][i]    = win[1][i]    = 0.5 * sin( M_PI / 72.0 * (double) (2*(i+0) +1) ) / cos ( M_PI * (double) (2*(i+0) +19) / 72.0 );
  147.     win[0][i+18] = win[3][i+18] = 0.5 * sin( M_PI / 72.0 * (double) (2*(i+18)+1) ) / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 );
  148.   }
  149.   for(i=0;i<6;i++)
  150.   {
  151.     win[1][i+18] = 0.5 / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 );
  152.     win[3][i+12] = 0.5 / cos ( M_PI * (double) (2*(i+12)+19) / 72.0 );
  153.     win[1][i+24] = 0.5 * sin( M_PI / 24.0 * (double) (2*i+13) ) / cos ( M_PI * (double) (2*(i+24)+19) / 72.0 );
  154.     win[1][i+30] = win[3][i] = 0.0;
  155.     win[3][i+6 ] = 0.5 * sin( M_PI / 24.0 * (double) (2*i+1) )  / cos ( M_PI * (double) (2*(i+6 )+19) / 72.0 );
  156.   }
  157.  
  158.   for(i=0;i<9;i++)
  159.     COS9[i] = cos( M_PI / 18.0 * (double) i);
  160.  
  161.   for(i=0;i<9;i++)
  162.     tfcos36[i] = 0.5 / cos ( M_PI * (double) (i*2+1) / 36.0 );
  163.   for(i=0;i<3;i++)
  164.     tfcos12[i] = 0.5 / cos ( M_PI * (double) (i*2+1) / 12.0 );
  165.  
  166.   COS6_1 = cos( M_PI / 6.0 * (double) 1);
  167.   COS6_2 = cos( M_PI / 6.0 * (double) 2);
  168.  
  169.   for(i=0;i<12;i++)
  170.   {
  171.     win[2][i]  = 0.5 * sin( M_PI / 24.0 * (double) (2*i+1) ) / cos ( M_PI * (double) (2*i+7) / 24.0 );
  172.     for(j=0;j<6;j++)
  173.       COS1[i][j] = cos( M_PI / 24.0 * (double) ((2*i+7)*(2*j+1)) );
  174.   }
  175.  
  176.   for(j=0;j<4;j++) {
  177.     static int len[4] = { 36,36,12,36 };
  178.     for(i=0;i<len[j];i+=2)
  179.       win1[j][i] = + win[j][i];
  180.     for(i=1;i<len[j];i+=2)
  181.       win1[j][i] = - win[j][i];
  182.   }
  183.  
  184.   for(i=0;i<16;i++)
  185.   {
  186.     double t = tan( (double) i * M_PI / 12.0 );
  187.     tan1_1[i] = t / (1.0+t);
  188.     tan2_1[i] = 1.0 / (1.0 + t);
  189.     tan1_2[i] = M_SQRT2 * t / (1.0+t);
  190.     tan2_2[i] = M_SQRT2 / (1.0 + t);
  191.  
  192.     for(j=0;j<2;j++) {
  193.       double base = pow(2.0,-0.25*(j+1.0));
  194.       double p1=1.0,p2=1.0;
  195.       if(i > 0) {
  196.         if( i & 1 )
  197.           p1 = pow(base,(i+1.0)*0.5);
  198.         else
  199.           p2 = pow(base,i*0.5);
  200.       }
  201.       pow1_1[j][i] = p1;
  202.       pow2_1[j][i] = p2;
  203.       pow1_2[j][i] = M_SQRT2 * p1;
  204.       pow2_2[j][i] = M_SQRT2 * p2;
  205.     }
  206.   }
  207.  
  208.   for(j=0;j<9;j++)
  209.   {
  210.    struct bandInfoStruct *bi = (struct bandInfoStruct *)&bandInfo[j];
  211.    int *mp;
  212.    int cb,lwin;
  213.    short *bdf;
  214.  
  215.    mp = map[j][0] = mapbuf0[j];
  216.    bdf = bi->longDiff;
  217.    for(i=0,cb = 0; cb < 8 ; cb++,i+=*bdf++) {
  218.      *mp++ = (*bdf) >> 1;
  219.      *mp++ = i;
  220.      *mp++ = 3;
  221.      *mp++ = cb;
  222.    }
  223.    bdf = bi->shortDiff+3;
  224.    for(cb=3;cb<13;cb++) {
  225.      int l = (*bdf++) >> 1;
  226.      for(lwin=0;lwin<3;lwin++) {
  227.        *mp++ = l;
  228.        *mp++ = i + lwin;
  229.        *mp++ = lwin;
  230.        *mp++ = cb;
  231.      }
  232.      i += 6*l;
  233.    }
  234.    mapend[j][0] = mp;
  235.  
  236.    mp = map[j][1] = mapbuf1[j];
  237.    bdf = bi->shortDiff+0;
  238.    for(i=0,cb=0;cb<13;cb++) {
  239.      int l = (*bdf++) >> 1;
  240.      for(lwin=0;lwin<3;lwin++) {
  241.        *mp++ = l;
  242.        *mp++ = i + lwin;
  243.        *mp++ = lwin;
  244.        *mp++ = cb;
  245.      }
  246.      i += 6*l;
  247.    }
  248.    mapend[j][1] = mp;
  249.  
  250.    mp = map[j][2] = mapbuf2[j];
  251.    bdf = bi->longDiff;
  252.    for(cb = 0; cb < 22 ; cb++) {
  253.      *mp++ = (*bdf++) >> 1;
  254.      *mp++ = cb;
  255.    }
  256.    mapend[j][2] = mp;
  257.  
  258.   }
  259.  
  260.   for(j=0;j<9;j++) {
  261.     for(i=0;i<23;i++) {
  262.       longLimit[j][i] = (bandInfo[j].longIdx[i] - 1 + 8) / 18 + 1;
  263.       if(longLimit[j][i] > (down_sample_sblimit) )
  264.         longLimit[j][i] = down_sample_sblimit;
  265.     }
  266.     for(i=0;i<14;i++) {
  267.       shortLimit[j][i] = (bandInfo[j].shortIdx[i] - 1) / 18 + 1;
  268.       if(shortLimit[j][i] > (down_sample_sblimit) )
  269.         shortLimit[j][i] = down_sample_sblimit;
  270.     }
  271.   }
  272.  
  273.   for(i=0;i<5;i++) {
  274.     for(j=0;j<6;j++) {
  275.       for(k=0;k<6;k++) {
  276.         int n = k + j * 6 + i * 36;
  277.         i_slen2[n] = i|(j<<3)|(k<<6)|(3<<12);
  278.       }
  279.     }
  280.   }
  281.   for(i=0;i<4;i++) {
  282.     for(j=0;j<4;j++) {
  283.       for(k=0;k<4;k++) {
  284.         int n = k + j * 4 + i * 16;
  285.         i_slen2[n+180] = i|(j<<3)|(k<<6)|(4<<12);
  286.       }
  287.     }
  288.   }
  289.   for(i=0;i<4;i++) {
  290.     for(j=0;j<3;j++) {
  291.       int n = j + i * 3;
  292.       i_slen2[n+244] = i|(j<<3) | (5<<12);
  293.       n_slen2[n+500] = i|(j<<3) | (2<<12) | (1<<15);
  294.     }
  295.   }
  296.  
  297.   for(i=0;i<5;i++) {
  298.     for(j=0;j<5;j++) {
  299.       for(k=0;k<4;k++) {
  300.         int l;
  301.         for(l=0;l<4;l++) {
  302.           int n = l + k * 4 + j * 16 + i * 80;
  303.           n_slen2[n] = i|(j<<3)|(k<<6)|(l<<9)|(0<<12);
  304.         }
  305.       }
  306.     }
  307.   }
  308.   for(i=0;i<5;i++) {
  309.     for(j=0;j<5;j++) {
  310.       for(k=0;k<4;k++) {
  311.         int n = k + j * 4 + i * 20;
  312.         n_slen2[n+400] = i|(j<<3)|(k<<6)|(1<<12);
  313.       }
  314.     }
  315.   }
  316. }
  317.  
  318. /*
  319.  * read additional side information
  320.  */
  321. #ifdef MPEG1 
  322. static void III_get_side_info_1(struct III_sideinfo *si,int stereo,
  323.  int ms_stereo,long sfreq,int single)
  324. {
  325.    int ch, gr;
  326.    int powdiff = (single == 3) ? 4 : 0;
  327.  
  328.    si->main_data_begin = getbits(9);
  329.    if (stereo == 1)
  330.      si->private_bits = getbits_fast(5);
  331.    else 
  332.      si->private_bits = getbits_fast(3);
  333.  
  334.    for (ch=0; ch<stereo; ch++) {
  335.        si->ch[ch].gr[0].scfsi = -1;
  336.        si->ch[ch].gr[1].scfsi = getbits_fast(4);
  337.    }
  338.  
  339.    for (gr=0; gr<2; gr++) 
  340.    {
  341.      for (ch=0; ch<stereo; ch++) 
  342.      {
  343.        register struct gr_info_s *gr_infos = &(si->ch[ch].gr[gr]);
  344.  
  345.        gr_infos->part2_3_length = getbits(12);
  346.        gr_infos->big_values = getbits_fast(9);
  347.        if(gr_infos->big_values > 288) {
  348.           fprintf(stderr,"big_values too large! %i\n",gr_infos->big_values);
  349.           gr_infos->big_values = 288;
  350.        }
  351.        {
  352.      unsigned int qss = getbits_fast(8);
  353.      gr_infos->pow2gain = gainpow2+256 - qss + powdiff;
  354. #ifndef NOANALYSIS
  355.      if (mpg123_pinfo != NULL) {
  356.        mpg123_pinfo->qss[gr][ch]=qss;
  357.      }
  358. #endif
  359.        }
  360.        if(ms_stereo)
  361.          gr_infos->pow2gain += 2;
  362.        gr_infos->scalefac_compress = getbits_fast(4);
  363. /* window-switching flag == 1 for block_Type != 0 .. and block-type == 0 -> win-sw-flag = 0 */
  364.        if(get1bit()) 
  365.        {
  366.          int i;
  367.          gr_infos->block_type = getbits_fast(2);
  368.          gr_infos->mixed_block_flag = get1bit();
  369.          gr_infos->table_select[0] = getbits_fast(5);
  370.          gr_infos->table_select[1] = getbits_fast(5);
  371.  
  372.  
  373.          /*
  374.           * table_select[2] not needed, because there is no region2,
  375.           * but to satisfy some verifications tools we set it either.
  376.           */
  377.          gr_infos->table_select[2] = 0;
  378.          for(i=0;i<3;i++) {
  379.        unsigned int sbg = (getbits_fast(3)<<3);
  380.            gr_infos->full_gain[i] = gr_infos->pow2gain + sbg;
  381. #ifndef NOANALYSIS
  382.        if (mpg123_pinfo != NULL)
  383.          mpg123_pinfo->sub_gain[gr][ch][i]=sbg/8;
  384. #endif
  385.      }
  386.  
  387.          if(gr_infos->block_type == 0) {
  388.            fprintf(stderr,"Blocktype == 0 and window-switching == 1 not allowed.\n");
  389.            /* error seems to be very good recoverable, so don't exit */
  390.            /* exit(1); */
  391.          }
  392.          /* region_count/start parameters are implicit in this case. */       
  393.          gr_infos->region1start = 36>>1;
  394.          gr_infos->region2start = 576>>1;
  395.        }
  396.        else 
  397.        {
  398.          int i,r0c,r1c;
  399.          for (i=0; i<3; i++)
  400.            gr_infos->table_select[i] = getbits_fast(5);
  401.          r0c = getbits_fast(4);
  402.          r1c = getbits_fast(3);
  403.          gr_infos->region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ;
  404.          gr_infos->region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1;
  405.          gr_infos->block_type = 0;
  406.          gr_infos->mixed_block_flag = 0;
  407.        }
  408.        gr_infos->preflag = get1bit();
  409.        gr_infos->scalefac_scale = get1bit();
  410.        gr_infos->count1table_select = get1bit();
  411.      }
  412.    }
  413. }
  414. #endif
  415.  
  416. /*
  417.  * Side Info for MPEG 2.0 / LSF
  418.  */
  419. static void III_get_side_info_2(struct III_sideinfo *si,int stereo,
  420.  int ms_stereo,long sfreq,int single)
  421. {
  422.    int ch;
  423.    int powdiff = (single == 3) ? 4 : 0;
  424.  
  425.    si->main_data_begin = getbits(8);
  426.  
  427.    if (stereo == 1)
  428.      si->private_bits = get1bit();
  429.    else 
  430.      si->private_bits = getbits_fast(2);
  431.  
  432.    for (ch=0; ch<stereo; ch++) 
  433.    {
  434.        register struct gr_info_s *gr_infos = &(si->ch[ch].gr[0]);
  435.        unsigned int qss;
  436.  
  437.        gr_infos->part2_3_length = getbits(12);
  438.        gr_infos->big_values = getbits_fast(9);
  439.        if(gr_infos->big_values > 288) {
  440.          fprintf(stderr,"big_values too large! %i\n",gr_infos->big_values);
  441.          gr_infos->big_values = 288;
  442.        }
  443.        qss=getbits_fast(8);
  444.        gr_infos->pow2gain = gainpow2+256 - qss + powdiff;
  445. #ifndef NOANALYSIS
  446.        if (mpg123_pinfo!=NULL) {
  447.        mpg123_pinfo->qss[0][ch]=qss;
  448.        }
  449. #endif
  450.  
  451.  
  452.        if(ms_stereo)
  453.          gr_infos->pow2gain += 2;
  454.        gr_infos->scalefac_compress = getbits(9);
  455. /* window-switching flag == 1 for block_Type != 0 .. and block-type == 0 -> win-sw-flag = 0 */
  456.        if(get1bit()) 
  457.        {
  458.          int i;
  459.          gr_infos->block_type = getbits_fast(2);
  460.          gr_infos->mixed_block_flag = get1bit();
  461.          gr_infos->table_select[0] = getbits_fast(5);
  462.          gr_infos->table_select[1] = getbits_fast(5);
  463.          /*
  464.           * table_select[2] not needed, because there is no region2,
  465.           * but to satisfy some verifications tools we set it either.
  466.           */
  467.          gr_infos->table_select[2] = 0;
  468.          for(i=0;i<3;i++) {
  469.        unsigned int sbg = (getbits_fast(3)<<3);
  470.            gr_infos->full_gain[i] = gr_infos->pow2gain + sbg;
  471. #ifndef NOANALYSIS
  472.        if (mpg123_pinfo!=NULL)
  473.          mpg123_pinfo->sub_gain[0][ch][i]=sbg/8;
  474. #endif
  475.  
  476.      }
  477.  
  478.          if(gr_infos->block_type == 0) {
  479.            fprintf(stderr,"Blocktype == 0 and window-switching == 1 not allowed.\n");
  480.            /* error seems to be very good recoverable, so don't exit */
  481.            /* exit(1); */
  482.          }
  483.          /* region_count/start parameters are implicit in this case. */       
  484. /* check this again! */
  485.          if(gr_infos->block_type == 2)
  486.            gr_infos->region1start = 36>>1;
  487.          else if(sfreq == 8)
  488. /* check this for 2.5 and sfreq=8 */
  489.            gr_infos->region1start = 108>>1;
  490.          else
  491.            gr_infos->region1start = 54>>1;
  492.          gr_infos->region2start = 576>>1;
  493.        }
  494.        else 
  495.        {
  496.          int i,r0c,r1c;
  497.          for (i=0; i<3; i++)
  498.            gr_infos->table_select[i] = getbits_fast(5);
  499.          r0c = getbits_fast(4);
  500.          r1c = getbits_fast(3);
  501.          gr_infos->region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ;
  502.          gr_infos->region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1;
  503.          gr_infos->block_type = 0;
  504.          gr_infos->mixed_block_flag = 0;
  505.        }
  506.        gr_infos->scalefac_scale = get1bit();
  507.        gr_infos->count1table_select = get1bit();
  508.    }
  509. }
  510.  
  511. /*
  512.  * read scalefactors
  513.  */
  514. #ifdef MPEG1
  515. static int III_get_scale_factors_1(int *scf,struct gr_info_s *gr_infos)
  516. {
  517.    static const unsigned char slen[2][16] = {
  518.      {0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
  519.      {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}
  520.    };
  521.    int numbits;
  522.    int num0 = slen[0][gr_infos->scalefac_compress];
  523.    int num1 = slen[1][gr_infos->scalefac_compress];
  524.  
  525.     if (gr_infos->block_type == 2) 
  526.     {
  527.       int i=18;
  528.       numbits = (num0 + num1) * 18;
  529.  
  530.       if (gr_infos->mixed_block_flag) {
  531.          for (i=8;i;i--)
  532.            *scf++ = getbits_fast(num0);
  533.          i = 9;
  534.          numbits -= num0; /* num0 * 17 + num1 * 18 */
  535.       }
  536.  
  537.       for (;i;i--)
  538.         *scf++ = getbits_fast(num0);
  539.       for (i = 18; i; i--)
  540.         *scf++ = getbits_fast(num1);
  541.       *scf++ = 0; *scf++ = 0; *scf++ = 0; /* short[13][0..2] = 0 */
  542.     }
  543.     else 
  544.     {
  545.       int i;
  546.       int scfsi = gr_infos->scfsi;
  547.  
  548.       if(scfsi < 0) { /* scfsi < 0 => granule == 0 */
  549.          for(i=11;i;i--)
  550.            *scf++ = getbits_fast(num0);
  551.          for(i=10;i;i--)
  552.            *scf++ = getbits_fast(num1);
  553.          numbits = (num0 + num1) * 10 + num0;
  554.       }
  555.       else {
  556.         numbits = 0;
  557.         if(!(scfsi & 0x8)) {
  558.           for (i=6;i;i--)
  559.             *scf++ = getbits_fast(num0);
  560.           numbits += num0 * 6;
  561.         }
  562.         else {
  563.           scf += 6;
  564.         }
  565.  
  566.         if(!(scfsi & 0x4)) {
  567.           for (i=5;i;i--)
  568.             *scf++ = getbits_fast(num0);
  569.           numbits += num0 * 5;
  570.         }
  571.         else {
  572.           scf += 5;
  573.         }
  574.  
  575.         if(!(scfsi & 0x2)) {
  576.           for(i=5;i;i--)
  577.             *scf++ = getbits_fast(num1);
  578.           numbits += num1 * 5;
  579.         }
  580.         else {
  581.           scf += 5;
  582.         }
  583.  
  584.         if(!(scfsi & 0x1)) {
  585.           for (i=5;i;i--)
  586.             *scf++ = getbits_fast(num1);
  587.           numbits += num1 * 5;
  588.         }
  589.         else {
  590.           scf += 5;
  591.         }
  592.       }
  593.  
  594.       *scf++ = 0;  /* no l[21] in original sources */
  595.     }
  596.     return numbits;
  597. }
  598. #endif
  599.  
  600. static int III_get_scale_factors_2(int *scf,struct gr_info_s *gr_infos,int i_stereo)
  601. {
  602.   unsigned char *pnt;
  603.   int i,j;
  604.   unsigned int slen;
  605.   int n = 0;
  606.   int numbits = 0;
  607.  
  608.   static const unsigned char stab[3][6][4] = {
  609.    { { 6, 5, 5,5 } , { 6, 5, 7,3 } , { 11,10,0,0} ,
  610.      { 7, 7, 7,0 } , { 6, 6, 6,3 } , {  8, 8,5,0} } ,
  611.    { { 9, 9, 9,9 } , { 9, 9,12,6 } , { 18,18,0,0} ,
  612.      {12,12,12,0 } , {12, 9, 9,6 } , { 15,12,9,0} } ,
  613.    { { 6, 9, 9,9 } , { 6, 9,12,6 } , { 15,18,0,0} ,
  614.      { 6,15,12,0 } , { 6,12, 9,6 } , {  6,18,9,0} } }; 
  615.  
  616.   if(i_stereo) /* i_stereo AND second channel -> do_layer3() checks this */
  617.     slen = i_slen2[gr_infos->scalefac_compress>>1];
  618.   else
  619.     slen = n_slen2[gr_infos->scalefac_compress];
  620.  
  621.   gr_infos->preflag = (slen>>15) & 0x1;
  622.  
  623.   n = 0;  
  624.   if( gr_infos->block_type == 2 ) {
  625.     n++;
  626.     if(gr_infos->mixed_block_flag)
  627.       n++;
  628.   }
  629.  
  630.   pnt = (unsigned char *)stab[n][(slen>>12)&0x7];
  631.  
  632.   for(i=0;i<4;i++) {
  633.     int num = slen & 0x7;
  634.     slen >>= 3;
  635.     if(num) {
  636.       for(j=0;j<(int)(pnt[i]);j++)
  637.         *scf++ = getbits_fast(num);
  638.       numbits += pnt[i] * num;
  639.     }
  640.     else {
  641.       for(j=0;j<(int)(pnt[i]);j++)
  642.         *scf++ = 0;
  643.     }
  644.   }
  645.   
  646.   n = (n << 1) + 1;
  647.   for(i=0;i<n;i++)
  648.     *scf++ = 0;
  649.  
  650.   return numbits;
  651. }
  652.  
  653. static const int pretab1 [22] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,3,3,3,2,0}; /* char enough ? */
  654. static const int pretab2 [22] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  655.  
  656. /*
  657.  * don't forget to apply the same changes to III_dequantize_sample_ms() !!! 
  658.  */
  659. static int III_dequantize_sample(real xr[SBLIMIT][SSLIMIT],int *scf,
  660.    struct gr_info_s *gr_infos,int sfreq,int part2bits)
  661. {
  662.   int shift = 1 + gr_infos->scalefac_scale;
  663.   real *xrpnt = (real *) xr;
  664.   int l[3],l3;
  665.   int part2remain = gr_infos->part2_3_length - part2bits;
  666.   int *me;
  667.  
  668.   {
  669.     int i;
  670.     
  671.     for(i=(&xr[SBLIMIT][0]-xrpnt)>>1;i>0;i--) {
  672.       *xrpnt++ = 0.0;
  673.       *xrpnt++ = 0.0;
  674.     }
  675.  
  676.     xrpnt = (real *) xr;
  677.   }
  678.  
  679.   {
  680.     int bv       = gr_infos->big_values;
  681.     int region1  = gr_infos->region1start;
  682.     int region2  = gr_infos->region2start;
  683.  
  684.     l3 = ((576>>1)-bv)>>1;   
  685. /*
  686.  * we may lose the 'odd' bit here !! 
  687.  * check this later again 
  688.  */
  689.     if(bv <= region1) {
  690.       l[0] = bv; l[1] = 0; l[2] = 0;
  691.     }
  692.     else {
  693.       l[0] = region1;
  694.       if(bv <= region2) {
  695.         l[1] = bv - l[0];  l[2] = 0;
  696.       }
  697.       else {
  698.         l[1] = region2 - l[0]; l[2] = bv - region2;
  699.       }
  700.     }
  701.   }
  702.  
  703.   if(gr_infos->block_type == 2) {
  704.     /*
  705.      * decoding with short or mixed mode BandIndex table 
  706.      */
  707.     int i,max[4];
  708.     int step=0,lwin=0,cb=0;
  709.     register real v = 0.0;
  710.     register int *m,mc;
  711.  
  712.     if(gr_infos->mixed_block_flag) {
  713.       max[3] = -1;
  714.       max[0] = max[1] = max[2] = 2;
  715.       m = map[sfreq][0];
  716.       me = mapend[sfreq][0];
  717.     }
  718.     else {
  719.       max[0] = max[1] = max[2] = max[3] = -1;
  720.       /* max[3] not really needed in this case */
  721.       m = map[sfreq][1];
  722.       me = mapend[sfreq][1];
  723.     }
  724.  
  725.     mc = 0;
  726.     for(i=0;i<2;i++) {
  727.       int lp = l[i];
  728.       struct newhuff *h = (struct newhuff *)(ht+gr_infos->table_select[i]);
  729.       for(;lp;lp--,mc--) {
  730.         register int x,y;
  731.         if( (!mc) ) {
  732.           mc = *m++;
  733.           xrpnt = ((real *) xr) + (*m++);
  734.           lwin = *m++;
  735.           cb = *m++;
  736.           if(lwin == 3) {
  737.             v = gr_infos->pow2gain[(*scf++) << shift];
  738.             step = 1;
  739.           }
  740.           else {
  741.             v = gr_infos->full_gain[lwin][(*scf++) << shift];
  742.             step = 3;
  743.           }
  744.         }
  745.         {
  746.           register short *val = (short *)h->table;
  747.           while((y=*val++)<0) {
  748.             if (get1bit())
  749.               val -= y;
  750.             part2remain--;
  751.           }
  752.           x = y >> 4;
  753.           y &= 0xf;
  754.         }
  755.         if(x == 15) {
  756.           max[lwin] = cb;
  757.           part2remain -= h->linbits+1;
  758.           x += getbits((int)h->linbits);
  759.           if(get1bit())
  760.             *xrpnt = -ispow[x] * v;
  761.           else
  762.             *xrpnt =  ispow[x] * v;
  763.         }
  764.         else if(x) {
  765.           max[lwin] = cb;
  766.           if(get1bit())
  767.             *xrpnt = -ispow[x] * v;
  768.           else
  769.             *xrpnt =  ispow[x] * v;
  770.           part2remain--;
  771.         }
  772.         else
  773.           *xrpnt = 0.0;
  774.         xrpnt += step;
  775.         if(y == 15) {
  776.           max[lwin] = cb;
  777.           part2remain -= h->linbits+1;
  778.           y += getbits((int)h->linbits);
  779.           if(get1bit())
  780.             *xrpnt = -ispow[y] * v;
  781.           else
  782.             *xrpnt =  ispow[y] * v;
  783.         }
  784.         else if(y) {
  785.           max[lwin] = cb;
  786.           if(get1bit())
  787.             *xrpnt = -ispow[y] * v;
  788.           else
  789.             *xrpnt =  ispow[y] * v;
  790.           part2remain--;
  791.         }
  792.         else
  793.           *xrpnt = 0.0;
  794.         xrpnt += step;
  795.       }
  796.     }
  797.     for(;l3 && (part2remain > 0);l3--) {
  798.       struct newhuff *h = (struct newhuff *)(htc+gr_infos->count1table_select);
  799.       register short *val = (short *)h->table,a;
  800.  
  801.       while((a=*val++)<0) {
  802.         part2remain--;
  803.         if(part2remain < 0) {
  804.           part2remain++;
  805.           a = 0;
  806.           break;
  807.         }
  808.         if (get1bit())
  809.           val -= a;
  810.       }
  811.       for(i=0;i<4;i++) {
  812.         if(!(i & 1)) {
  813.           if(!mc) {
  814.             mc = *m++;
  815.             xrpnt = ((real *) xr) + (*m++);
  816.             lwin = *m++;
  817.             cb = *m++;
  818.             if(lwin == 3) {
  819.               v = gr_infos->pow2gain[(*scf++) << shift];
  820.               step = 1;
  821.             }
  822.             else {
  823.               v = gr_infos->full_gain[lwin][(*scf++) << shift];
  824.               step = 3;
  825.             }
  826.           }
  827.           mc--;
  828.         }
  829.         if( (a & (0x8>>i)) ) {
  830.           max[lwin] = cb;
  831.           part2remain--;
  832.           if(part2remain < 0) {
  833.             part2remain++;
  834.             break;
  835.           }
  836.           if(get1bit()) 
  837.             *xrpnt = -v;
  838.           else
  839.             *xrpnt = v;
  840.         }
  841.         else
  842.           *xrpnt = 0.0;
  843.         xrpnt += step;
  844.       }
  845.     }
  846.  
  847.     while( m < me ) {
  848.       if(!mc) {
  849.         mc = *m++;
  850.         xrpnt = ((real *) xr) + *m++;
  851.         if( (*m++) == 3)
  852.           step = 1;
  853.         else
  854.           step = 3;
  855.         m++; /* cb */
  856.       }
  857.       mc--;
  858.       *xrpnt = 0.0;
  859.       xrpnt += step;
  860.       *xrpnt = 0.0;
  861.       xrpnt += step;
  862. /* we could add a little opt. here:
  863.  * if we finished a band for window 3 or a long band
  864.  * further bands could copied in a simple loop without a
  865.  * special 'map' decoding
  866.  */
  867.     }
  868.  
  869.     gr_infos->maxband[0] = max[0]+1;
  870.     gr_infos->maxband[1] = max[1]+1;
  871.     gr_infos->maxband[2] = max[2]+1;
  872.     gr_infos->maxbandl = max[3]+1;
  873.  
  874.     {
  875.       int rmax = max[0] > max[1] ? max[0] : max[1];
  876.       rmax = (rmax > max[2] ? rmax : max[2]) + 1;
  877.       gr_infos->maxb = rmax ? shortLimit[sfreq][rmax] : longLimit[sfreq][max[3]+1];
  878.     }
  879.  
  880.   }
  881.   else {
  882.     /*
  883.      * decoding with 'long' BandIndex table (block_type != 2)
  884.      */
  885.     int *pretab = (int *)(gr_infos->preflag ? pretab1 : pretab2);
  886.     int i,max = -1;
  887.     int cb = 0;
  888.     register int *m = map[sfreq][2];
  889.     register real v = 0.0;
  890.     register int mc = 0;
  891. #if 0
  892.     me = mapend[sfreq][2];
  893. #endif
  894.  
  895.     /*
  896.      * long hash table values
  897.      */
  898.     for(i=0;i<3;i++) {
  899.       int lp = l[i];
  900.       struct newhuff *h = (struct newhuff *)(ht+gr_infos->table_select[i]);
  901.  
  902.       for(;lp;lp--,mc--) {
  903.         int x,y;
  904.  
  905.         if(!mc) {
  906.           mc = *m++;
  907.           v = gr_infos->pow2gain[((*scf++) + (*pretab++)) << shift];
  908.           cb = *m++;
  909.         }
  910.         {
  911.           register short *val = (short *)h->table;
  912.           while((y=*val++)<0) {
  913.             if (get1bit())
  914.               val -= y;
  915.             part2remain--;
  916.           }
  917.           x = y >> 4;
  918.           y &= 0xf;
  919.         }
  920.         if (x == 15) {
  921.           max = cb;
  922.           part2remain -= h->linbits+1;
  923.           x += getbits((int)h->linbits);
  924.           if(get1bit())
  925.             *xrpnt++ = -ispow[x] * v;
  926.           else
  927.             *xrpnt++ =  ispow[x] * v;
  928.         }
  929.         else if(x) {
  930.           max = cb;
  931.           if(get1bit())
  932.             *xrpnt++ = -ispow[x] * v;
  933.           else
  934.             *xrpnt++ =  ispow[x] * v;
  935.           part2remain--;
  936.         }
  937.         else
  938.           *xrpnt++ = 0.0;
  939.  
  940.         if (y == 15) {
  941.           max = cb;
  942.           part2remain -= h->linbits+1;
  943.           y += getbits((int)h->linbits);
  944.           if(get1bit())
  945.             *xrpnt++ = -ispow[y] * v;
  946.           else
  947.             *xrpnt++ =  ispow[y] * v;
  948.         }
  949.         else if(y) {
  950.           max = cb;
  951.           if(get1bit())
  952.             *xrpnt++ = -ispow[y] * v;
  953.           else
  954.             *xrpnt++ =  ispow[y] * v;
  955.           part2remain--;
  956.         }
  957.         else
  958.           *xrpnt++ = 0.0;
  959.       }
  960.     }
  961.  
  962.     /*
  963.      * short (count1table) values
  964.      */
  965.     for(;l3 && (part2remain > 0);l3--) {
  966.       struct newhuff *h = (struct newhuff *)(htc+gr_infos->count1table_select);
  967.       register short *val = (short *)h->table,a;
  968.  
  969.       while((a=*val++)<0) {
  970.         part2remain--;
  971.         if(part2remain < 0) {
  972.           part2remain++;
  973.           a = 0;
  974.           break;
  975.         }
  976.         if (get1bit())
  977.           val -= a;
  978.       }
  979.       for(i=0;i<4;i++) {
  980.         if(!(i & 1)) {
  981.           if(!mc) {
  982.             mc = *m++;
  983.             cb = *m++;
  984.             v = gr_infos->pow2gain[((*scf++) + (*pretab++)) << shift];
  985.           }
  986.           mc--;
  987.         }
  988.         if ( (a & (0x8>>i)) ) {
  989.           max = cb;
  990.           part2remain--;
  991.           if(part2remain < 0) {
  992.             part2remain++;
  993.             break;
  994.           }
  995.           if(get1bit())
  996.             *xrpnt++ = -v;
  997.           else
  998.             *xrpnt++ = v;
  999.         }
  1000.         else
  1001.           *xrpnt++ = 0.0;
  1002.       }
  1003.     }
  1004.  
  1005.     /* 
  1006.      * zero part
  1007.      */
  1008.     for(i=(&xr[SBLIMIT][0]-xrpnt)>>1;i;i--) {
  1009.       *xrpnt++ = 0.0;
  1010.       *xrpnt++ = 0.0;
  1011.     }
  1012.  
  1013.     gr_infos->maxbandl = max+1;
  1014.     gr_infos->maxb = longLimit[sfreq][gr_infos->maxbandl];
  1015.   }
  1016.  
  1017.   while( part2remain > 16 ) {
  1018.     getbits(16); /* Dismiss stuffing Bits */
  1019.     part2remain -= 16;
  1020.   }
  1021.   if(part2remain > 0)
  1022.     getbits(part2remain);
  1023.   else if(part2remain < 0) {
  1024.     fprintf(stderr,"mpg123: Can't rewind stream by %d bits!\n",-part2remain);
  1025.     return 1; /* -> error */
  1026.   }
  1027.   return 0;
  1028. }
  1029.  
  1030.  
  1031. /* 
  1032.  * III_stereo: calculate real channel values for Joint-I-Stereo-mode
  1033.  */
  1034. static void III_i_stereo(real xr_buf[2][SBLIMIT][SSLIMIT],int *scalefac,
  1035.    struct gr_info_s *gr_infos,int sfreq,int ms_stereo,int lsf)
  1036. {
  1037.       real (*xr)[SBLIMIT*SSLIMIT] = (real (*)[SBLIMIT*SSLIMIT] ) xr_buf;
  1038.       struct bandInfoStruct *bi = (struct bandInfoStruct *)&bandInfo[sfreq];
  1039.       real *tabl1,*tabl2;
  1040.  
  1041.       if(lsf) {
  1042.         int p = gr_infos->scalefac_compress & 0x1;
  1043.         if(ms_stereo) {
  1044.           tabl1 = pow1_2[p]; tabl2 = pow2_2[p];
  1045.         }
  1046.         else {
  1047.           tabl1 = pow1_1[p]; tabl2 = pow2_1[p];
  1048.         }
  1049.       }
  1050.       else {
  1051.         if(ms_stereo) {
  1052.           tabl1 = tan1_2; tabl2 = tan2_2;
  1053.         }
  1054.         else {
  1055.           tabl1 = tan1_1; tabl2 = tan2_1;
  1056.         }
  1057.       }
  1058.  
  1059.       if (gr_infos->block_type == 2)
  1060.       {
  1061.          int lwin,do_l = 0;
  1062.          if( gr_infos->mixed_block_flag )
  1063.            do_l = 1;
  1064.  
  1065.          for (lwin=0;lwin<3;lwin++) /* process each window */
  1066.          {
  1067.              /* get first band with zero values */
  1068.            int is_p,sb,idx,sfb = gr_infos->maxband[lwin];  /* sfb is minimal 3 for mixed mode */
  1069.            if(sfb > 3)
  1070.              do_l = 0;
  1071.  
  1072.            for(;sfb<12;sfb++)
  1073.            {
  1074.              is_p = scalefac[sfb*3+lwin-gr_infos->mixed_block_flag]; /* scale: 0-15 */ 
  1075.              if(is_p != 7) {
  1076.                real t1,t2;
  1077.                sb = bi->shortDiff[sfb];
  1078.                idx = bi->shortIdx[sfb] + lwin;
  1079.                t1 = tabl1[is_p]; t2 = tabl2[is_p];
  1080.                for (; sb > 0; sb--,idx+=3)
  1081.                {
  1082.                  real v = xr[0][idx];
  1083.                  xr[0][idx] = v * t1;
  1084.                  xr[1][idx] = v * t2;
  1085.                }
  1086.              }
  1087.            }
  1088.  
  1089. #if 1
  1090. /* in the original: copy 10 to 11 , here: copy 11 to 12 
  1091. maybe still wrong??? (copy 12 to 13?) */
  1092.            is_p = scalefac[11*3+lwin-gr_infos->mixed_block_flag]; /* scale: 0-15 */
  1093.            sb = bi->shortDiff[12];
  1094.            idx = bi->shortIdx[12] + lwin;
  1095. #else
  1096.            is_p = scalefac[10*3+lwin-gr_infos->mixed_block_flag]; /* scale: 0-15 */
  1097.            sb = bi->shortDiff[11];
  1098.            idx = bi->shortIdx[11] + lwin;
  1099. #endif
  1100.            if(is_p != 7)
  1101.            {
  1102.              real t1,t2;
  1103.              t1 = tabl1[is_p]; t2 = tabl2[is_p];
  1104.              for ( ; sb > 0; sb--,idx+=3 )
  1105.              {  
  1106.                real v = xr[0][idx];
  1107.                xr[0][idx] = v * t1;
  1108.                xr[1][idx] = v * t2;
  1109.              }
  1110.            }
  1111.          } /* end for(lwin; .. ; . ) */
  1112.  
  1113.          if (do_l)
  1114.          {
  1115. /* also check l-part, if ALL bands in the three windows are 'empty'
  1116.  * and mode = mixed_mode 
  1117.  */
  1118.            int sfb = gr_infos->maxbandl;
  1119.            int idx = bi->longIdx[sfb];
  1120.  
  1121.            for ( ; sfb<8; sfb++ )
  1122.            {
  1123.              int sb = bi->longDiff[sfb];
  1124.              int is_p = scalefac[sfb]; /* scale: 0-15 */
  1125.              if(is_p != 7) {
  1126.                real t1,t2;
  1127.                t1 = tabl1[is_p]; t2 = tabl2[is_p];
  1128.                for ( ; sb > 0; sb--,idx++)
  1129.                {
  1130.                  real v = xr[0][idx];
  1131.                  xr[0][idx] = v * t1;
  1132.                  xr[1][idx] = v * t2;
  1133.                }
  1134.              }
  1135.              else 
  1136.                idx += sb;
  1137.            }
  1138.          }     
  1139.       } 
  1140.       else /* ((gr_infos->block_type != 2)) */
  1141.       {
  1142.         int sfb = gr_infos->maxbandl;
  1143.         int is_p,idx = bi->longIdx[sfb];
  1144.         for ( ; sfb<21; sfb++)
  1145.         {
  1146.           int sb = bi->longDiff[sfb];
  1147.           is_p = scalefac[sfb]; /* scale: 0-15 */
  1148.           if(is_p != 7) {
  1149.             real t1,t2;
  1150.             t1 = tabl1[is_p]; t2 = tabl2[is_p];
  1151.             for ( ; sb > 0; sb--,idx++)
  1152.             {
  1153.                real v = xr[0][idx];
  1154.                xr[0][idx] = v * t1;
  1155.                xr[1][idx] = v * t2;
  1156.             }
  1157.           }
  1158.           else
  1159.             idx += sb;
  1160.         }
  1161.  
  1162.         is_p = scalefac[20]; /* copy l-band 20 to l-band 21 */
  1163.         if(is_p != 7)
  1164.         {
  1165.           int sb;
  1166.           real t1 = tabl1[is_p],t2 = tabl2[is_p]; 
  1167.  
  1168.           for ( sb = bi->longDiff[21]; sb > 0; sb--,idx++ )
  1169.           {
  1170.             real v = xr[0][idx];
  1171.             xr[0][idx] = v * t1;
  1172.             xr[1][idx] = v * t2;
  1173.           }
  1174.         }
  1175.       } /* ... */
  1176. }
  1177.  
  1178. static void III_antialias(real xr[SBLIMIT][SSLIMIT],struct gr_info_s *gr_infos)
  1179. {
  1180.    int sblim;
  1181.  
  1182.    if(gr_infos->block_type == 2)
  1183.    {
  1184.       if(!gr_infos->mixed_block_flag) 
  1185.         return;
  1186.       sblim = 1; 
  1187.    }
  1188.    else {
  1189.      sblim = gr_infos->maxb-1;
  1190.    }
  1191.  
  1192.    /* 31 alias-reduction operations between each pair of sub-bands */
  1193.    /* with 8 butterflies between each pair                         */
  1194.  
  1195.    {
  1196.      int sb;
  1197.      real *xr1=(real *) xr[1];
  1198.  
  1199.      for(sb=sblim;sb;sb--,xr1+=10)
  1200.      {
  1201.        int ss;
  1202.        real *cs=aa_cs,*ca=aa_ca;
  1203.        real *xr2 = xr1;
  1204.  
  1205.        for(ss=7;ss>=0;ss--)
  1206.        {       /* upper and lower butterfly inputs */
  1207.          register real bu = *--xr2,bd = *xr1;
  1208.          *xr2   = (bu * (*cs)   ) - (bd * (*ca)   );
  1209.          *xr1++ = (bd * (*cs++) ) + (bu * (*ca++) );
  1210.        }
  1211.      }
  1212.   }
  1213. }
  1214.  
  1215. /*
  1216.  DCT insipired by Jeff Tsay's DCT from the maplay package
  1217.  this is an optimized version with manual unroll.
  1218.  
  1219.  References:
  1220.  [1] S. Winograd: "On Computing the Discrete Fourier Transform",
  1221.      Mathematics of Computation, Volume 32, Number 141, January 1978,
  1222.      Pages 175-199
  1223. */
  1224.  
  1225. static void dct36(real *inbuf,real *o1,real *o2,real *wintab,real *tsbuf)
  1226. {
  1227.   {
  1228.     register real *in = inbuf;
  1229.  
  1230.     in[17]+=in[16]; in[16]+=in[15]; in[15]+=in[14];
  1231.     in[14]+=in[13]; in[13]+=in[12]; in[12]+=in[11];
  1232.     in[11]+=in[10]; in[10]+=in[9];  in[9] +=in[8];
  1233.     in[8] +=in[7];  in[7] +=in[6];  in[6] +=in[5];
  1234.     in[5] +=in[4];  in[4] +=in[3];  in[3] +=in[2];
  1235.     in[2] +=in[1];  in[1] +=in[0];
  1236.  
  1237.     in[17]+=in[15]; in[15]+=in[13]; in[13]+=in[11]; in[11]+=in[9];
  1238.     in[9] +=in[7];  in[7] +=in[5];  in[5] +=in[3];  in[3] +=in[1];
  1239.  
  1240.  
  1241.   {
  1242.  
  1243. #define MACRO0(v) { \
  1244.     real tmp; \
  1245.     out2[9+(v)] = (tmp = sum0 + sum1) * w[27+(v)]; \
  1246.     out2[8-(v)] = tmp * w[26-(v)];  } \
  1247.     sum0 -= sum1; \
  1248.     ts[SBLIMIT*(8-(v))] = out1[8-(v)] + sum0 * w[8-(v)]; \
  1249.     ts[SBLIMIT*(9+(v))] = out1[9+(v)] + sum0 * w[9+(v)]; 
  1250. #define MACRO1(v) { \
  1251.     real sum0,sum1; \
  1252.     sum0 = tmp1a + tmp2a; \
  1253.     sum1 = (tmp1b + tmp2b) * tfcos36[(v)]; \
  1254.     MACRO0(v); }
  1255. #define MACRO2(v) { \
  1256.     real sum0,sum1; \
  1257.     sum0 = tmp2a - tmp1a; \
  1258.     sum1 = (tmp2b - tmp1b) * tfcos36[(v)]; \
  1259.     MACRO0(v); }
  1260.  
  1261.     register const real *c = COS9;
  1262.     register real *out2 = o2;
  1263.     register real *w = wintab;
  1264.     register real *out1 = o1;
  1265.     register real *ts = tsbuf;
  1266.  
  1267.     real ta33,ta66,tb33,tb66;
  1268.  
  1269.     ta33 = in[2*3+0] * c[3];
  1270.     ta66 = in[2*6+0] * c[6];
  1271.     tb33 = in[2*3+1] * c[3];
  1272.     tb66 = in[2*6+1] * c[6];
  1273.  
  1274.     { 
  1275.       real tmp1a,tmp2a,tmp1b,tmp2b;
  1276.       tmp1a =             in[2*1+0] * c[1] + ta33 + in[2*5+0] * c[5] + in[2*7+0] * c[7];
  1277.       tmp1b =             in[2*1+1] * c[1] + tb33 + in[2*5+1] * c[5] + in[2*7+1] * c[7];
  1278.       tmp2a = in[2*0+0] + in[2*2+0] * c[2] + in[2*4+0] * c[4] + ta66 + in[2*8+0] * c[8];
  1279.       tmp2b = in[2*0+1] + in[2*2+1] * c[2] + in[2*4+1] * c[4] + tb66 + in[2*8+1] * c[8];
  1280.  
  1281.       MACRO1(0);
  1282.       MACRO2(8);
  1283.     }
  1284.  
  1285.     {
  1286.       real tmp1a,tmp2a,tmp1b,tmp2b;
  1287.       tmp1a = ( in[2*1+0] - in[2*5+0] - in[2*7+0] ) * c[3];
  1288.       tmp1b = ( in[2*1+1] - in[2*5+1] - in[2*7+1] ) * c[3];
  1289.       tmp2a = ( in[2*2+0] - in[2*4+0] - in[2*8+0] ) * c[6] - in[2*6+0] + in[2*0+0];
  1290.       tmp2b = ( in[2*2+1] - in[2*4+1] - in[2*8+1] ) * c[6] - in[2*6+1] + in[2*0+1];
  1291.  
  1292.       MACRO1(1);
  1293.       MACRO2(7);
  1294.     }
  1295.  
  1296.     {
  1297.       real tmp1a,tmp2a,tmp1b,tmp2b;
  1298.       tmp1a =             in[2*1+0] * c[5] - ta33 - in[2*5+0] * c[7] + in[2*7+0] * c[1];
  1299.       tmp1b =             in[2*1+1] * c[5] - tb33 - in[2*5+1] * c[7] + in[2*7+1] * c[1];
  1300.       tmp2a = in[2*0+0] - in[2*2+0] * c[8] - in[2*4+0] * c[2] + ta66 + in[2*8+0] * c[4];
  1301.       tmp2b = in[2*0+1] - in[2*2+1] * c[8] - in[2*4+1] * c[2] + tb66 + in[2*8+1] * c[4];
  1302.  
  1303.       MACRO1(2);
  1304.       MACRO2(6);
  1305.     }
  1306.  
  1307.     {
  1308.       real tmp1a,tmp2a,tmp1b,tmp2b;
  1309.       tmp1a =             in[2*1+0] * c[7] - ta33 + in[2*5+0] * c[1] - in[2*7+0] * c[5];
  1310.       tmp1b =             in[2*1+1] * c[7] - tb33 + in[2*5+1] * c[1] - in[2*7+1] * c[5];
  1311.       tmp2a = in[2*0+0] - in[2*2+0] * c[4] + in[2*4+0] * c[8] + ta66 - in[2*8+0] * c[2];
  1312.       tmp2b = in[2*0+1] - in[2*2+1] * c[4] + in[2*4+1] * c[8] + tb66 - in[2*8+1] * c[2];
  1313.  
  1314.       MACRO1(3);
  1315.       MACRO2(5);
  1316.     }
  1317.  
  1318.     {
  1319.         real sum0,sum1;
  1320.         sum0 =  in[2*0+0] - in[2*2+0] + in[2*4+0] - in[2*6+0] + in[2*8+0];
  1321.         sum1 = (in[2*0+1] - in[2*2+1] + in[2*4+1] - in[2*6+1] + in[2*8+1] ) * tfcos36[4];
  1322.         MACRO0(4);
  1323.     }
  1324.   }
  1325.  
  1326.   }
  1327. }
  1328.  
  1329. /*
  1330.  * new DCT12
  1331.  */
  1332. static void dct12(real *in,real *rawout1,real *rawout2,register real *wi,register real *ts)
  1333. {
  1334. #define DCT12_PART1 \
  1335.              in5 = in[5*3];  \
  1336.      in5 += (in4 = in[4*3]); \
  1337.      in4 += (in3 = in[3*3]); \
  1338.      in3 += (in2 = in[2*3]); \
  1339.      in2 += (in1 = in[1*3]); \
  1340.      in1 += (in0 = in[0*3]); \
  1341.                              \
  1342.      in5 += in3; in3 += in1; \
  1343.                              \
  1344.      in2 *= COS6_1; \
  1345.      in3 *= COS6_1; \
  1346.  
  1347. #define DCT12_PART2 \
  1348.      in0 += in4 * COS6_2; \
  1349.                           \
  1350.      in4 = in0 + in2;     \
  1351.      in0 -= in2;          \
  1352.                           \
  1353.      in1 += in5 * COS6_2; \
  1354.                           \
  1355.      in5 = (in1 + in3) * tfcos12[0]; \
  1356.      in1 = (in1 - in3) * tfcos12[2]; \
  1357.                          \
  1358.      in3 = in4 + in5;    \
  1359.      in4 -= in5;         \
  1360.                          \
  1361.      in2 = in0 + in1;    \
  1362.      in0 -= in1;
  1363.  
  1364.  
  1365.    {
  1366.      real in0,in1,in2,in3,in4,in5;
  1367.      register real *out1 = rawout1;
  1368.      ts[SBLIMIT*0] = out1[0]; ts[SBLIMIT*1] = out1[1]; ts[SBLIMIT*2] = out1[2];
  1369.      ts[SBLIMIT*3] = out1[3]; ts[SBLIMIT*4] = out1[4]; ts[SBLIMIT*5] = out1[5];
  1370.  
  1371.      DCT12_PART1
  1372.  
  1373.      {
  1374.        real tmp0,tmp1 = (in0 - in4);
  1375.        {
  1376.          real tmp2 = (in1 - in5) * tfcos12[1];
  1377.          tmp0 = tmp1 + tmp2;
  1378.          tmp1 -= tmp2;
  1379.        }
  1380.        ts[(17-1)*SBLIMIT] = out1[17-1] + tmp0 * wi[11-1];
  1381.        ts[(12+1)*SBLIMIT] = out1[12+1] + tmp0 * wi[6+1];
  1382.        ts[(6 +1)*SBLIMIT] = out1[6 +1] + tmp1 * wi[1];
  1383.        ts[(11-1)*SBLIMIT] = out1[11-1] + tmp1 * wi[5-1];
  1384.      }
  1385.  
  1386.      DCT12_PART2
  1387.  
  1388.      ts[(17-0)*SBLIMIT] = out1[17-0] + in2 * wi[11-0];
  1389.      ts[(12+0)*SBLIMIT] = out1[12+0] + in2 * wi[6+0];
  1390.      ts[(12+2)*SBLIMIT] = out1[12+2] + in3 * wi[6+2];
  1391.      ts[(17-2)*SBLIMIT] = out1[17-2] + in3 * wi[11-2];
  1392.  
  1393.      ts[(6+0)*SBLIMIT]  = out1[6+0] + in0 * wi[0];
  1394.      ts[(11-0)*SBLIMIT] = out1[11-0] + in0 * wi[5-0];
  1395.      ts[(6+2)*SBLIMIT]  = out1[6+2] + in4 * wi[2];
  1396.      ts[(11-2)*SBLIMIT] = out1[11-2] + in4 * wi[5-2];
  1397.   }
  1398.  
  1399.   in++;
  1400.  
  1401.   {
  1402.      real in0,in1,in2,in3,in4,in5;
  1403.      register real *out2 = rawout2;
  1404.  
  1405.      DCT12_PART1
  1406.  
  1407.      {
  1408.        real tmp0,tmp1 = (in0 - in4);
  1409.        {
  1410.          real tmp2 = (in1 - in5) * tfcos12[1];
  1411.          tmp0 = tmp1 + tmp2;
  1412.          tmp1 -= tmp2;
  1413.        }
  1414.        out2[5-1] = tmp0 * wi[11-1];
  1415.        out2[0+1] = tmp0 * wi[6+1];
  1416.        ts[(12+1)*SBLIMIT] += tmp1 * wi[1];
  1417.        ts[(17-1)*SBLIMIT] += tmp1 * wi[5-1];
  1418.      }
  1419.  
  1420.      DCT12_PART2
  1421.  
  1422.      out2[5-0] = in2 * wi[11-0];
  1423.      out2[0+0] = in2 * wi[6+0];
  1424.      out2[0+2] = in3 * wi[6+2];
  1425.      out2[5-2] = in3 * wi[11-2];
  1426.  
  1427.      ts[(12+0)*SBLIMIT] += in0 * wi[0];
  1428.      ts[(17-0)*SBLIMIT] += in0 * wi[5-0];
  1429.      ts[(12+2)*SBLIMIT] += in4 * wi[2];
  1430.      ts[(17-2)*SBLIMIT] += in4 * wi[5-2];
  1431.   }
  1432.  
  1433.   in++; 
  1434.  
  1435.   {
  1436.      real in0,in1,in2,in3,in4,in5;
  1437.      register real *out2 = rawout2;
  1438.      out2[12]=out2[13]=out2[14]=out2[15]=out2[16]=out2[17]=0.0;
  1439.  
  1440.      DCT12_PART1
  1441.  
  1442.      {
  1443.        real tmp0,tmp1 = (in0 - in4);
  1444.        {
  1445.          real tmp2 = (in1 - in5) * tfcos12[1];
  1446.          tmp0 = tmp1 + tmp2;
  1447.          tmp1 -= tmp2;
  1448.        }
  1449.        out2[11-1] = tmp0 * wi[11-1];
  1450.        out2[6 +1] = tmp0 * wi[6+1];
  1451.        out2[0+1] += tmp1 * wi[1];
  1452.        out2[5-1] += tmp1 * wi[5-1];
  1453.      }
  1454.  
  1455.      DCT12_PART2
  1456.  
  1457.      out2[11-0] = in2 * wi[11-0];
  1458.      out2[6 +0] = in2 * wi[6+0];
  1459.      out2[6 +2] = in3 * wi[6+2];
  1460.      out2[11-2] = in3 * wi[11-2];
  1461.  
  1462.      out2[0+0] += in0 * wi[0];
  1463.      out2[5-0] += in0 * wi[5-0];
  1464.      out2[0+2] += in4 * wi[2];
  1465.      out2[5-2] += in4 * wi[5-2];
  1466.   }
  1467. }
  1468.  
  1469. /*
  1470.  * III_hybrid
  1471.  */
  1472. static void III_hybrid( PMPSTR mp, real fsIn[SBLIMIT][SSLIMIT],real tsOut[SSLIMIT][SBLIMIT],
  1473.    int ch,struct gr_info_s *gr_infos)
  1474. {
  1475.    real *tspnt = (real *) tsOut;
  1476.    real (*block)[2][SBLIMIT*SSLIMIT] = mp->hybrid_block;
  1477.    int *blc = mp->hybrid_blc;
  1478.    real *rawout1,*rawout2;
  1479.    int bt;
  1480.    int sb = 0;
  1481.  
  1482.    {
  1483.      int b = blc[ch];
  1484.      rawout1=block[b][ch];
  1485.      b=-b+1;
  1486.      rawout2=block[b][ch];
  1487.      blc[ch] = b;
  1488.    }
  1489.  
  1490.   
  1491.    if(gr_infos->mixed_block_flag) {
  1492.      sb = 2;
  1493.      dct36(fsIn[0],rawout1,rawout2,win[0],tspnt);
  1494.      dct36(fsIn[1],rawout1+18,rawout2+18,win1[0],tspnt+1);
  1495.      rawout1 += 36; rawout2 += 36; tspnt += 2;
  1496.    }
  1497.  
  1498.    bt = gr_infos->block_type;
  1499.    if(bt == 2) {
  1500.      for (; sb<(int)gr_infos->maxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) {
  1501.        dct12(fsIn[sb],rawout1,rawout2,win[2],tspnt);
  1502.        dct12(fsIn[sb+1],rawout1+18,rawout2+18,win1[2],tspnt+1);
  1503.      }
  1504.    }
  1505.    else {
  1506.      for (; sb<(int)gr_infos->maxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) {
  1507.        dct36(fsIn[sb],rawout1,rawout2,win[bt],tspnt);
  1508.        dct36(fsIn[sb+1],rawout1+18,rawout2+18,win1[bt],tspnt+1);
  1509.      }
  1510.    }
  1511.  
  1512.    for(;sb<SBLIMIT;sb++,tspnt++) {
  1513.      int i;
  1514.      for(i=0;i<SSLIMIT;i++) {
  1515.        tspnt[i*SBLIMIT] = *rawout1++;
  1516.        *rawout2++ = 0.0;
  1517.      }
  1518.    }
  1519. }
  1520.  
  1521. /*
  1522.  * main layer3 handler
  1523.  */
  1524. struct III_sideinfo sideinfo;
  1525.  
  1526. int do_layer3_sideinfo(struct frame *fr)
  1527. {
  1528.   int stereo = fr->stereo;
  1529.   int single = fr->single;
  1530.   int ms_stereo;
  1531.   int sfreq = fr->sampling_frequency;
  1532.   int granules;
  1533.   int ch,gr,databits;
  1534.  
  1535.   if(stereo == 1) { /* stream is mono */
  1536.     single = 0;
  1537.   }
  1538.  
  1539.   if(fr->mode == MPG_MD_JOINT_STEREO) {
  1540.     ms_stereo = fr->mode_ext & 0x2;
  1541.   }
  1542.   else
  1543.     ms_stereo = 0;
  1544.  
  1545.  
  1546.   if(fr->lsf) {
  1547.     granules = 1;
  1548.     III_get_side_info_2(&sideinfo,stereo,ms_stereo,sfreq,single);
  1549.   }
  1550.   else {
  1551.     granules = 2;
  1552. #ifdef MPEG1
  1553.     III_get_side_info_1(&sideinfo,stereo,ms_stereo,sfreq,single);
  1554. #else
  1555.     fprintf(stderr,"Not supported\n");
  1556. #endif
  1557.   }
  1558.  
  1559.   databits=0;
  1560.   for (gr=0 ; gr < granules ; ++gr) {
  1561.     for (ch=0; ch < stereo ; ++ch) {
  1562.       struct gr_info_s *gr_infos = &(sideinfo.ch[ch].gr[gr]);
  1563.       databits += gr_infos->part2_3_length;
  1564.     }
  1565.   }
  1566.   return databits-8*sideinfo.main_data_begin;
  1567. }
  1568.  
  1569.  
  1570.  
  1571. int do_layer3( PMPSTR mp,unsigned char *pcm_sample,int *pcm_point)
  1572. {
  1573.   int gr, ch, ss,clip=0;
  1574.   int scalefacs[2][39]; /* max 39 for short[13][3] mode, mixed: 38, long: 22 */
  1575.   //  struct III_sideinfo sideinfo;
  1576.   struct frame *fr=&(mp->fr);
  1577.   int stereo = fr->stereo;
  1578.   int single = fr->single;
  1579.   int ms_stereo,i_stereo;
  1580.   int sfreq = fr->sampling_frequency;
  1581.   int stereo1,granules;
  1582.  
  1583.   if(set_pointer(mp, (int)sideinfo.main_data_begin) == MP3_ERR)
  1584.     return 0;
  1585.  
  1586.   if(stereo == 1) { /* stream is mono */
  1587.     stereo1 = 1;
  1588.     single = 0;
  1589.   }
  1590.   else if(single >= 0) /* stream is stereo, but force to mono */
  1591.     stereo1 = 1;
  1592.   else
  1593.     stereo1 = 2;
  1594.  
  1595.   if(fr->mode == MPG_MD_JOINT_STEREO) {
  1596.     ms_stereo = fr->mode_ext & 0x2;
  1597.     i_stereo  = fr->mode_ext & 0x1;
  1598.   }
  1599.   else
  1600.     ms_stereo = i_stereo = 0;
  1601.  
  1602.  
  1603.   if(fr->lsf) {
  1604.     granules = 1;
  1605.   }
  1606.   else {
  1607.     granules = 2;
  1608.   }
  1609.  
  1610.  
  1611.   for (gr=0;gr<granules;gr++) 
  1612.   {
  1613.     static real hybridIn[2][SBLIMIT][SSLIMIT];
  1614.     static real hybridOut[2][SSLIMIT][SBLIMIT];
  1615.  
  1616.     {
  1617.       struct gr_info_s *gr_infos = &(sideinfo.ch[0].gr[gr]);
  1618.       long part2bits;
  1619.  
  1620.       if(fr->lsf)
  1621.         part2bits = III_get_scale_factors_2(scalefacs[0],gr_infos,0);
  1622.       else {
  1623. #ifdef MPEG1
  1624.         part2bits = III_get_scale_factors_1(scalefacs[0],gr_infos);
  1625. #else
  1626.     fprintf(stderr,"Not supported\n");
  1627. #endif
  1628.       }
  1629.  
  1630. #ifndef NOANALYSIS
  1631.       if (mpg123_pinfo!=NULL) {
  1632.     int i;
  1633.     mpg123_pinfo->sfbits[gr][0] = part2bits;
  1634.     for (i=0; i<39; i++) 
  1635.       mpg123_pinfo->sfb_s[gr][0][i]=scalefacs[0][i];
  1636.       }
  1637. #endif
  1638.  
  1639.       if(III_dequantize_sample(hybridIn[0], scalefacs[0],gr_infos,sfreq,part2bits))
  1640.         return clip;
  1641.     }
  1642.     if(stereo == 2) {
  1643.       struct gr_info_s *gr_infos = &(sideinfo.ch[1].gr[gr]);
  1644.       long part2bits;
  1645.       if(fr->lsf) 
  1646.         part2bits = III_get_scale_factors_2(scalefacs[1],gr_infos,i_stereo);
  1647.       else {
  1648. #ifdef MPEG1
  1649.         part2bits = III_get_scale_factors_1(scalefacs[1],gr_infos);
  1650. #else
  1651.     fprintf(stderr,"Not supported\n");
  1652. #endif
  1653.       }
  1654. #ifndef NOANALYSIS
  1655.       if (mpg123_pinfo!=NULL) {
  1656.     int i;
  1657.     mpg123_pinfo->sfbits[gr][1] = part2bits;
  1658.     for (i=0; i<39; i++) 
  1659.       mpg123_pinfo->sfb_s[gr][1][i]=scalefacs[1][i];
  1660.       }
  1661. #endif
  1662.  
  1663.       if(III_dequantize_sample(hybridIn[1],scalefacs[1],gr_infos,sfreq,part2bits))
  1664.           return clip;
  1665.  
  1666.       if(ms_stereo) {
  1667.         int i;
  1668.         for(i=0;i<SBLIMIT*SSLIMIT;i++) {
  1669.           real tmp0,tmp1;
  1670.           tmp0 = ((real *) hybridIn[0])[i];
  1671.           tmp1 = ((real *) hybridIn[1])[i];
  1672.           ((real *) hybridIn[1])[i] = tmp0 - tmp1;  
  1673.           ((real *) hybridIn[0])[i] = tmp0 + tmp1;
  1674.         }
  1675.       }
  1676.  
  1677.       if(i_stereo)
  1678.         III_i_stereo(hybridIn,scalefacs[1],gr_infos,sfreq,ms_stereo,fr->lsf);
  1679.  
  1680.       if(ms_stereo || i_stereo || (single == 3) ) {
  1681.         if(gr_infos->maxb > sideinfo.ch[0].gr[gr].maxb) 
  1682.           sideinfo.ch[0].gr[gr].maxb = gr_infos->maxb;
  1683.         else
  1684.           gr_infos->maxb = sideinfo.ch[0].gr[gr].maxb;
  1685.       }
  1686.  
  1687.       switch(single) {
  1688.         case 3:
  1689.           {
  1690.             register int i;
  1691.             register real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1];
  1692.             for(i=0;i<(int)(SSLIMIT*gr_infos->maxb);i++,in0++)
  1693.               *in0 = (*in0 + *in1++); /* *0.5 done by pow-scale */ 
  1694.           }
  1695.           break;
  1696.         case 1:
  1697.           {
  1698.             register int i;
  1699.             register real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1];
  1700.             for(i=0;i<(int)(SSLIMIT*gr_infos->maxb);i++)
  1701.               *in0++ = *in1++;
  1702.           }
  1703.           break;
  1704.       }
  1705.     }
  1706.  
  1707. #ifndef NOANALYSIS
  1708.     if (mpg123_pinfo!=NULL) {
  1709.     int i,sb;
  1710.     float ifqstep;
  1711.  
  1712.     mpg123_pinfo->bitrate = 
  1713.       tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index];
  1714.     mpg123_pinfo->sampfreq = freqs[sfreq];
  1715.     mpg123_pinfo->emph = fr->emphasis;
  1716.     mpg123_pinfo->crc = fr->error_protection;
  1717.     mpg123_pinfo->padding = fr->padding;
  1718.     mpg123_pinfo->stereo = fr->stereo;
  1719.     mpg123_pinfo->js =   (fr->mode == MPG_MD_JOINT_STEREO);
  1720.     mpg123_pinfo->ms_stereo = ms_stereo;
  1721.     mpg123_pinfo->i_stereo = i_stereo;
  1722.     mpg123_pinfo->maindata = sideinfo.main_data_begin;
  1723.  
  1724.     for(ch=0;ch<stereo1;ch++) {
  1725.       struct gr_info_s *gr_infos = &(sideinfo.ch[ch].gr[gr]);
  1726.       mpg123_pinfo->big_values[gr][ch]=gr_infos->big_values;
  1727.       mpg123_pinfo->scalefac_scale[gr][ch]=gr_infos->scalefac_scale;
  1728.       mpg123_pinfo->mixed[gr][ch] = gr_infos->mixed_block_flag;
  1729.       mpg123_pinfo->mpg123blocktype[gr][ch]=gr_infos->block_type;
  1730.       mpg123_pinfo->mainbits[gr][ch] = gr_infos->part2_3_length;
  1731.       mpg123_pinfo->preflag[gr][ch] = gr_infos->preflag;
  1732.       if (gr==1) mpg123_pinfo->scfsi[ch] = gr_infos->scfsi;
  1733.     }
  1734.  
  1735.  
  1736.     for (ch=0;ch<stereo1;ch++) {
  1737.       struct gr_info_s *gr_infos = &(sideinfo.ch[ch].gr[gr]);
  1738.       ifqstep = ( mpg123_pinfo->scalefac_scale[gr][ch] == 0 ) ? .5 : 1.0;
  1739.       if (2==gr_infos->block_type) {
  1740.     for (i=0; i<3; i++) {
  1741.       for (sb=0; sb<12; sb++) {
  1742.         int j = 3*sb+i;
  1743.         /*
  1744.            is_p = scalefac[sfb*3+lwin-gr_infos->mixed_block_flag]; 
  1745.         */
  1746.         /* scalefac was copied into mpg123_pinfo->sfb_s[] above */
  1747.         mpg123_pinfo->sfb_s[gr][ch][j] = -ifqstep*mpg123_pinfo->sfb_s[gr][ch][j-gr_infos->mixed_block_flag];
  1748.         mpg123_pinfo->sfb_s[gr][ch][j] -= 2*(mpg123_pinfo->sub_gain[gr][ch][i]);
  1749.       }
  1750.       mpg123_pinfo->sfb_s[gr][ch][3*sb+i] = - 2*(mpg123_pinfo->sub_gain[gr][ch][i]);
  1751.     }
  1752.       }else{
  1753.     for (sb=0; sb<21; sb++) {
  1754.       /* scalefac was copied into mpg123_pinfo->sfb[] above */
  1755.       mpg123_pinfo->sfb[gr][ch][sb] = mpg123_pinfo->sfb_s[gr][ch][sb];
  1756.       if (gr_infos->preflag) mpg123_pinfo->sfb[gr][ch][sb] += pretab1[sb];
  1757.       mpg123_pinfo->sfb[gr][ch][sb] *= -ifqstep;
  1758.     }
  1759.     mpg123_pinfo->sfb[gr][ch][21]=0;
  1760.       }
  1761.     }
  1762.  
  1763.  
  1764.     
  1765.     for(ch=0;ch<stereo1;ch++) { 
  1766.       int j=0;
  1767.       for (sb=0;sb<SBLIMIT;sb++)
  1768.     for(ss=0;ss<SSLIMIT;ss++,j++) 
  1769.       mpg123_pinfo->mpg123xr[gr][ch][j]=hybridIn[ch][sb][ss];
  1770.     }
  1771.   }
  1772. #endif
  1773.  
  1774.  
  1775.     for(ch=0;ch<stereo1;ch++) {
  1776.       struct gr_info_s *gr_infos = &(sideinfo.ch[ch].gr[gr]);
  1777.       III_antialias(hybridIn[ch],gr_infos);
  1778.       III_hybrid(mp, hybridIn[ch], hybridOut[ch], ch,gr_infos);
  1779.     }
  1780.  
  1781.     for(ss=0;ss<SSLIMIT;ss++) {
  1782.       if(single >= 0) {
  1783.         clip += synth_1to1_mono(mp, hybridOut[0][ss],pcm_sample,pcm_point);
  1784.       }
  1785.       else {
  1786.         int p1 = *pcm_point;
  1787.         clip += synth_1to1(mp, hybridOut[0][ss],0,pcm_sample,&p1);
  1788.         clip += synth_1to1(mp, hybridOut[1][ss],1,pcm_sample,pcm_point);
  1789.       }
  1790.     }
  1791.   }
  1792.   
  1793.   return clip;
  1794. }
  1795.  
  1796.